home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / UIFlow 1.0.1 / UIFlow Source / VSet2.0 / Src / vio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-20  |  15.8 KB  |  699 lines  |  [TEXT/????]
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF Vset release 2.1
  4. *                    May 1991
  5. *
  6. * NCSA HDF Vset release 2.1 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************
  21. * Likkai Ng NCSA May 1991
  22. *
  23. * vio.c
  24. * Part of the HDF Vset interface.
  25. *
  26. * VDATAs are handled by routines in here.
  27. * PRIVATE functions manipulate vsdir and are used only within this file.
  28. * PRIVATE data structures in here pertain to vdatas in vsdir only.
  29. *
  30. *************************************************************************/
  31.  
  32. #include <stdio.h>
  33. #include "vg.h"
  34.  
  35. /* ------------------------------------------------------------------ */
  36. /*
  37. DFvsetopen and DFvsetclose
  38. */
  39. #undef DFopen
  40. #undef DFclose
  41.  
  42. PUBLIC DF * DFvsetopen (fname, access, defDDs )
  43. char * fname;
  44. int access, defDDs;
  45. {
  46.     DF * f;
  47.     f = DFopen(fname, access, defDDs);
  48.     Vinitialize(f);
  49.     /* sprintf(sjs,"DFvsetopen called\n"); zj; */
  50.     return (f);
  51. }
  52. /* ------------------------------------------------------------------ */
  53. PUBLIC int DFvsetclose (dfile)
  54. DF * dfile;
  55. {
  56.     int s;
  57.  
  58.     s = DFclose(dfile);
  59.     return (s);
  60. }
  61.  
  62. /* ------------------------------------------------------------------ */
  63. /*
  64. * Looks thru vstab for vsid and return the addr of the vdata instance
  65. * where vsid is found.
  66. * RETURNS NULL if error or not found.
  67. * RETURNS vsinstance_t pointer if ok.
  68. *
  69. */
  70.  
  71. vsinstance_t * vsinstance (f,vsid)             /*@@*/
  72. DF  *f;
  73. int vsid;
  74.  
  75. {
  76.     vsinstance_t * w;
  77.     vfile_t      * vf;
  78.  
  79.     if (NULL== (vf = (vfile_t*) Get_vfile(f)))
  80.         RTNULL ("vsinstance: no such file\n");
  81.  
  82.     w = vf->vstab.next;
  83.     while (NULL != w) {
  84.         if (w->ref == vsid) return(w);
  85.         w = w->next;
  86.     }
  87.     return(NULL);
  88.  
  89. } /* vsinstance */
  90.  
  91. /* ------------------------------------------------------------------ */
  92. /*
  93. * Tests if a vdata with id vsid is in the file's vstab.
  94. * returns -1 if not found,
  95. * returns 1 if found.
  96. */
  97. int vexistvs (f,vsid)             /*@@*/
  98. DF  *f;
  99. int vsid;
  100. {
  101.     if (NULL== (vsinstance_t *) vsinstance(f,vsid))
  102.         return(-1);
  103.     else
  104.         return (1);
  105.  
  106. } /* vexistvs */
  107.  
  108. /* ------------------------------------------------------------------ */
  109. /*
  110. The following 2 routines, vpackvs and vunpackvs, packs and unpacks
  111. a VDATA structure into a compact form suitable for storing in the HDF file.
  112. */
  113.  
  114. /****
  115. CONTENTS of VS stored in HDF file with tag VSDESCTAG:
  116.     int16        interlace
  117.     int32        nvertices
  118.     int16        vsize
  119.     int16        nfields
  120.  
  121.     int16        isize[1..nfields] (internal size of each field)
  122.     int16        off[1..nfields] (internal offset of each field)
  123.     char        fname[1..nfields][FIELDNAMELENMAX]
  124.     char        vsname[VSNAMELENMAX]
  125. ****/
  126.  
  127.  
  128. #define INT16SIZE 2
  129. #define INT32SIZE 4
  130.  
  131. /* ------------------------------------------------------------------ */
  132. /*
  133. The following 2 PRIVATE routines, vpackvs and vunpackvs, packs and unpacks
  134. a VDATA structure into a compact form suitable for storing in the HDF file.
  135. */
  136.  
  137. /****
  138. CONTENTS of VS stored in HDF file with tag VSDESCTAG:
  139.     int16        interlace
  140.     int32        nvertices
  141.     int16        vsize
  142.     int16        nfields
  143.  
  144.     int16        isize[1..nfields] (internal size of each field)
  145.     int16        off[1..nfields] (internal offset of each field)
  146.     char        fname[1..nfields][FIELDNAMELENMAX]
  147.     char        vsname[VSNAMELENMAX]
  148. ****/
  149.  
  150. /* 
  151. convert a vs struct to a vspack suitable for storage in a HDF file 
  152. */
  153.  
  154. void vpackvs (vs,buf,size)         /*@@*/
  155.  
  156. VDATA *vs;
  157. int   *size;
  158. unsigned char buf[];
  159. {
  160.     int           i;
  161.     unsigned char *b, *bb;
  162.     int16         int16var;
  163.  
  164.  
  165.     bb = &buf[0];
  166.  
  167.     /* save the interlace */
  168.     b = bb;
  169.     INT16WRITE(b,vs->interlace);
  170.     bb+=INT16SIZE;
  171.  
  172.     /* save nvertices */
  173.     b = bb;
  174.     INT32WRITE(b,vs->nvertices);
  175.     bb+=INT32SIZE;
  176.  
  177.     /* save ivsize */
  178.     b = bb;
  179.     INT16WRITE(b,vs->wlist.ivsize);
  180.     bb+=INT16SIZE;
  181.  
  182.     /* save nfields */
  183.     b = bb;
  184.     INT16WRITE(b,vs->wlist.n);
  185.     bb+=INT16SIZE;
  186.  
  187.     for (i=0;i<vs->wlist.n;i++) { /* save the type */
  188.         b = bb;
  189.         INT16WRITE(b,vs->wlist.type[i]);
  190.         bb+=INT16SIZE;
  191.     }
  192.     for (i=0;i<vs->wlist.n;i++) { /* save the isize */
  193.         b = bb;
  194.         INT16WRITE(b,vs->wlist.isize[i]);
  195.         bb+=INT16SIZE;
  196.     }
  197.     for (i=0;i<vs->wlist.n;i++) { /* save the offset    */
  198.         b = bb;
  199.         INT16WRITE(b,vs->wlist.off[i]);
  200.         bb+=INT16SIZE;
  201.     }
  202.     for (i=0;i<vs->wlist.n;i++)  { /* save the order */
  203.         b = bb;
  204.         INT16WRITE(b,vs->wlist.order[i]);
  205.         bb+=INT16SIZE;
  206.     }
  207.  
  208.     /* save each field length and name - omit the null */
  209.     for (i=0;i<vs->wlist.n;i++) {
  210.         b = bb;
  211.         int16var = strlen(vs->wlist.name[i]);
  212.         INT16WRITE(b,int16var);
  213.         bb+=INT16SIZE;
  214.  
  215.         strcpy((char*) bb, vs->wlist.name[i]);
  216.         bb += strlen(vs->wlist.name[i]);
  217.     }
  218.  
  219.     /* save the vsnamelen and vsname - omit the null */
  220.     b = bb;
  221.     int16var = strlen(vs->vsname);
  222.     INT16WRITE(b,int16var);
  223.     bb+=INT16SIZE;
  224.  
  225.     strcpy((char*) bb,vs->vsname);
  226.     bb += strlen(vs->vsname);
  227.  
  228.     /* save the vsclasslen and vsclass- omit the null */
  229.     b = bb;
  230.     int16var = strlen(vs->vsclass);
  231.     INT16WRITE(b,int16var);
  232.     bb+=INT16SIZE;
  233.  
  234.     strcpy((char*) bb,vs->vsclass);
  235.     bb += strlen(vs->vsclass);
  236.  
  237.     /* save the expansion tag/ref pair */
  238.     b= bb;
  239.     INT16WRITE(b,vs->extag);
  240.     bb +=INT16SIZE;
  241.  
  242.     b= bb;
  243.     INT16WRITE(b,vs->exref);
  244.     bb +=INT16SIZE;
  245.  
  246.     /* save the version field - init to version_2 now */
  247.     b= bb;
  248.     INT16WRITE(b,vs->version);
  249.     bb +=INT16SIZE;
  250.  
  251.     /* save the 'more' field - NONE now */
  252.     b= bb;
  253.     INT16WRITE(b,vs->more);
  254.     bb +=INT16SIZE;
  255.  
  256.     *size = bb - buf + 1;
  257.  
  258. } /* vpackvs */
  259.  
  260. /* ------------------------------------------------------------------ */
  261. /* 
  262. Convert a packed form(from HDF file)  to a VDATA structure.
  263. This routine will also initalize the VDATA structure as much as it can.
  264. */
  265.  
  266. void vunpackvs (vs,buf,size)       /*@@*/
  267.  
  268. VDATA *vs;
  269. int   *size;            /* UNUSED, but retained for compatibility with vpackvs */
  270. unsigned char buf[];
  271. {
  272.     unsigned char *b, *bb;
  273.     int            i;
  274.     int                int16var;
  275.  
  276.     i = *size; /* dum */
  277.  
  278.     bb = &buf[0];
  279.  
  280.     /* retrieve interlace */
  281.     b = bb;
  282.     INT16READ(b,vs->interlace);
  283.     bb += INT16SIZE;
  284.  
  285.     /* retrieve nvertices */
  286.     b = bb;
  287.     INT32READ(b,vs->nvertices);
  288.     bb += INT32SIZE;
  289.  
  290.     /* retrieve tore ivsize */
  291.     b = bb;
  292.     INT16READ(b,vs->wlist.ivsize);
  293.     bb += INT16SIZE;
  294.  
  295.     /* retrieve nfields */
  296.     b = bb;
  297.     INT16READ(b,vs->wlist.n);
  298.     bb += INT16SIZE;
  299.  
  300.     for (i=0;i<vs->wlist.n;i++)  { /* retrieve the type */
  301.         b = bb;
  302.         INT16READ(b,vs->wlist.type[i]);
  303.         bb += INT16SIZE;
  304.     }
  305.  
  306.     for (i=0;i<vs->wlist.n;i++)  { /* retrieve the isize */
  307.         b = bb;
  308.         INT16READ(b,vs->wlist.isize[i]);
  309.         bb += INT16SIZE;
  310.     }
  311.  
  312.     for (i=0;i<vs->wlist.n;i++)  { /* retrieve the offset */
  313.         b = bb;
  314.         INT16READ(b,vs->wlist.off[i]);
  315.         bb += INT16SIZE;
  316.     }
  317.  
  318.     for (i=0;i<vs->wlist.n;i++)  { /* retrieve the order */
  319.         b = bb;
  320.         INT16READ(b,vs->wlist.order[i]);
  321.         bb += INT16SIZE;
  322.     }
  323.  
  324.     /* retrieve the field names (and each field name's length)  */
  325.     for (i=0;i<vs->wlist.n;i++) {
  326.         b = bb;
  327.         INT16READ(b,int16var); /* this gives the length */
  328.         bb += INT16SIZE;
  329.  
  330.         strncpy(vs->wlist.name[i], (char*) bb, int16var);
  331.         vs->wlist.name[i][int16var] = '\0';
  332.         bb += int16var;
  333.     }
  334.  
  335.     /* retrieve the vsname (and vsnamelen)  */
  336.     b = bb;
  337.     INT16READ(b,int16var); /* this gives the length */
  338.     bb += INT16SIZE;
  339.  
  340.     strncpy(vs->vsname, (char*) bb, int16var);
  341.     vs->vsname[int16var] = '\0';
  342.     bb += int16var;
  343.  
  344.     /* retrieve the vsclass (and vsclasslen)  */
  345.     b = bb;
  346.     INT16READ(b,int16var); /* this gives the length */
  347.     bb += INT16SIZE;
  348.  
  349.     strncpy(vs->vsclass, (char*) bb, int16var);
  350.     vs->vsclass[int16var] = '\0';
  351.     bb += int16var;
  352.  
  353.     /* retrieve the expansion tag and ref */
  354.     b = bb;
  355.     INT16READ(b,vs->extag);
  356.     bb += INT16SIZE;
  357.  
  358.     b = bb;
  359.     INT16READ(b,vs->exref);
  360.     bb += INT16SIZE;
  361.  
  362.     /* retrieve the version field */
  363.     b = bb;
  364.     INT16READ(b,vs->version);
  365.     bb += INT16SIZE;
  366.  
  367.     /* retrieve the 'more' field */
  368.     b = bb;
  369.     INT16READ(b,vs->more);
  370.     bb += INT16SIZE;
  371.  
  372.     /* **EXTRA**  fill in the machine-dependent size fields */
  373.     for (i=0;i<vs->wlist.n;i++) {
  374.         vs->wlist.esize[i] = vs->wlist.order[i] * SIZEOF(vs->wlist.type[i]);
  375.     }
  376.  
  377. } /* vunpackvs */
  378.  
  379. /* ------------------------------------------------------------------ */
  380.  
  381.  
  382.  
  383. /* ***************************************************************
  384.    VSattach: 
  385.     if vsid == -1, then
  386.     (a) if vg is "w", create a new vs in vg and attach it.
  387.                             add to vsdir, set nattach= 1, nvertices = 0.
  388.     (b) if vg is "r", forbidden.
  389.    if vsid is +ve, then
  390.     (a) if vg is "w"  => new data may be added BUT must be same format
  391.                                 as existing vdata.
  392.                                 (ie. VSsetfields must match old format exactly!!)
  393.  
  394.     (b) if vg is "r"  => look in vsdir
  395.                                 if not found,
  396.                                     fetch  vs from file, add to vsdir,  
  397.                                     set nattach= 1, nvertices = val from file.
  398.                                 if found,
  399.                                     check access of found vs
  400.                                     if "w" => being written, unstable! forbidden
  401.                                     if "r" => ok. incr nattach.
  402.     
  403.     in all cases, set the marked flag to 0.
  404.     returns NULL if error.
  405.    *************************************************************** */
  406.  
  407. PUBLIC VDATA * VSattach (f,vsid,accesstype)       /*@-@*/
  408.  
  409. DF        *f;
  410. int     vsid;
  411. char *accesstype;
  412. {
  413.     VDATA             *vs;               /* new vdata to be returned */
  414.     int                 vspacksize;
  415.     unsigned char     vspack[sizeof(VWRITELIST)];
  416.     int                access;
  417.     vsinstance_t    * w;
  418.     vfile_t            * vf;
  419.  
  420.     if (f==NULL)
  421.         RTNULL("vsattach:bad f");
  422.  
  423.     if (NULL==(vf = (vfile_t*) Get_vfile(f)))
  424.         RTNULL ("Vattach: no such file\n");
  425.  
  426.     if      ( accesstype[0]=='R' || accesstype[0]=='r') { 
  427.         access = 'r'; 
  428.     }
  429.     else if ( accesstype[0]=='W' || accesstype[0]=='w') { 
  430.         access = 'w'; 
  431.     }
  432.     else RTNULL("VSattach: bad access type");
  433.  
  434.     if (vjv) {
  435.         sprintf(sjs,"#VSATTACH:vsid=%d access=%s\n",vsid, accesstype);
  436.         zj;
  437.     }
  438.  
  439.     if (vsid < -1)    {            /* --------- ILLEGAL VSID ---------------------- */
  440.         RTNULL("VSattach:bad vsid");
  441.     }
  442.  
  443.     else if (vsid == -1) {  /* ---------- VSID IS -1 ----------------------- */
  444.         if (access == 'r') RTNULL("VSattach: may not read vsid of -1");
  445.         /* otherwise 'w' */
  446.  
  447.         /* allocate space for vs,  & zero it out  */
  448.         if ( (vs=(VDATA*) DFIgetspace(sizeof(VDATA))) == NULL)
  449.             RTNULL("VSattach: cannot getspace");
  450.         zerofill ((unsigned char*) vs,sizeof(VDATA));
  451.  
  452.         vs->oref                = vnewref(f);
  453.         if ( vs->oref < 0) RTNULL("VSattach: no more refs");
  454.         vs->otag                = VSDESCTAG;
  455.         vs->vsname[0]         = '\0';
  456.         vs->interlace        = FULL_INTERLACE; /* DEFAULT */
  457.         vs->access            = 'w';
  458.         vs->f                    = f;
  459.         vs->marked            = 0;
  460.  
  461.         vs->vsclass[0]        = '\0';
  462.         vs->extag            = 0;
  463.         vs->exref            = 0;
  464.         vs->more                = 0;
  465.         vs->version            = VSET_VERSION;
  466.  
  467.         /* attach new vs to file's vstab */
  468.         if ( NULL == (w = (vsinstance_t*) DFIgetspace(sizeof(vsinstance_t))))
  469.             RTNULL("VSattach: cannot getspace for vstab\n");
  470.  
  471.         vf->vstabtail->next = w;
  472.         vf->vstabtail      = w;
  473.         vf->vstabn++;
  474.         w->next        = NULL;
  475.  
  476.         w->ref       = vs->oref;
  477.         w->vs        = vs;
  478.         w->nattach   = 1;
  479.         w->nvertices = 0;
  480.  
  481.         return (vs);
  482.     }
  483.  
  484.  
  485.     else {                  /*  --------  VSID IS NON_NEGATIVE ------------- */
  486.  
  487.         if (access == 'w') {
  488.             RTNULL("VSattach: may not write to existing vs");
  489.         }
  490.         /* otherwise 'r' */
  491.  
  492.         if (NULL == (w = (vsinstance_t*) vsinstance (f,vsid)) )
  493.             RTNULL("VSattach: vsid not in vstab");
  494.  
  495.         if (w->vs != NULL) { /* already attached */
  496.             if ( (w->vs)->access == 'w') {
  497.                 RTNULL("VSattach: existing vs already attached for write");
  498.             }
  499.             else { /* existing vs as attached for 'r' */
  500.                 w->nattach ++;
  501.                 return (w->vs);
  502.             }
  503.         }
  504.         else { /* need to fetch from file */
  505.  
  506.             if (-1 ==  DFgetelement(f,VSDESCTAG,vsid,vspack) )
  507.                 RTNULL("VSattach: vs  not in file");
  508.  
  509.             /* allocate space for vs,  & zero it out  */
  510.             if ( (vs=(VDATA*) DFIgetspace(sizeof(VDATA))) == NULL)
  511.                 RTNULL("VSattach: cannot getspace");
  512.             zerofill((unsigned char*) vs,sizeof(VDATA));
  513.  
  514.             /* unpack the vs, then init all other fields in it */
  515.             vunpackvs (vs,vspack,&vspacksize);
  516.             vs->otag                = VSDESCTAG;
  517.             vs->oref                = vsid;
  518.             vs->access            = 'r';
  519.             vs->f                    = f;
  520.             vs->vpos             = 0;
  521.             vs->marked            = 0;
  522.  
  523.             /* attach vs to vsdir  at the vdata instance w */
  524.             w->vs        = vs;
  525.             w->nattach   = 1;
  526.             w->nvertices = vs->nvertices;
  527.  
  528.             return(vs);
  529.         }
  530.     }
  531.  
  532. } /* VSattach */
  533.  
  534. /* ------------------------------------------------------------------ */
  535.  
  536. /* *************************************************************** 
  537.      Detach vs from vstab. 
  538.  
  539.     if vs has "w" access,   ( <=> only attached ONCE! )
  540.         decr nattach.
  541.         if (nattach is not  0)  => bad error in code.
  542.         if nvertices (in vs) is 0) just free vs from vstab.
  543.  
  544.         if marked flag is 1
  545.             write out vs to file and set marked flag to 0.
  546.            free vs from vsdir.
  547.  
  548.     if vs has "r" access,   ( <=> only attached ONCE! )
  549.         decr nattach.
  550.         if (nattach is 0)   just free vs from vstab.
  551.             
  552.    *************************************************************** */
  553.  
  554. PUBLIC void VSdetach (vs)        /*@-@*/
  555.  
  556. VDATA  *vs;
  557. {
  558.     int                i, vspacksize;
  559.     unsigned char  vspack[sizeof(VWRITELIST)];
  560.     vsinstance_t     * w;
  561.     char                 ss[80];
  562.  
  563.     if (vs==NULL) RT("VSdetach: bad vs");
  564.     if (vs->otag != VSDESCTAG) return;
  565.  
  566.     /* locate vs's entry in vstab */
  567.     if (NULL ==( w = (vsinstance_t*) vsinstance (vs->f,vs->oref))) {
  568.         sprintf(sjs,"@Vdetach: vg not found\n");
  569.         zj;
  570.         return;
  571.     }
  572.  
  573.     w->nattach--;
  574.  
  575.     if (vs->access =='w') {
  576.         if (w->nattach != 0) {
  577.             sprintf(ss,"VSdetach: nattach serious error. [%d] not 0", w->nattach);
  578.             RT(ss);
  579.         }
  580.  
  581.         if (vs->marked)  { /* if marked , write out vdata's VSDESC to file */
  582.             if (vs->nvertices == 0) {
  583.             } /* if vdata is empty, don't write to file */
  584.             else {
  585.                 vpackvs(vs,vspack,&vspacksize);
  586.                 if ( DFputelement(vs->f,VSDESCTAG,vs->oref,vspack,vspacksize) == -1)
  587.                     RT("VSdetach: cannot write out vs");
  588.             }
  589.             vs->marked = 0;
  590.         }
  591.  
  592.         if (vjv && vs->nvertices<=0){
  593.             sprintf(sjs,"#VSdetach:vs->nver=%d!\n",vs->nvertices);
  594.             zj;
  595.         }
  596.  
  597.         /* remove all defined symbols */
  598.         for (i=0;i<vs->nusym;i++) DFIfreespace(vs->usym[i].name);
  599.         vs->nusym = 0;
  600.  
  601.         w->vs = NULL; /* detach vs from vsdir */
  602.         DFIfreespace(vs);
  603.     }
  604.     else { /* access was 'r' */
  605.         if (w->nattach == 0) {
  606.             w->vs = NULL; /* detach vs from vsdir */
  607.             DFIfreespace(vs);
  608.         }
  609.     }
  610.     return;
  611.  
  612. } /* VSdetach */
  613.  
  614. /* ------------------------------------------------------------------ */
  615.  
  616.  
  617. /* Visvs
  618. *  checks if an id in a vgroup refers to a VDATA
  619. *  RETURNS 1 if so
  620. *  RETURNS 0 if not, or if error.
  621. */
  622.  
  623. PUBLIC int Visvs (vg,id)           /*@-@*/
  624.  
  625. VGROUP  *vg;
  626. int id;
  627. {
  628.     int i;
  629.     for (i=0;i<vg->nvelt;i++)
  630.         if (vg->ref[i] == id && vg->tag[i]==VSDESCTAG) return(1);
  631.  
  632.     return(0);
  633.  
  634. } /* Visvs */
  635.  
  636. /* ======================================================= */
  637.  
  638. /* 
  639. returns the id of the next  VDATA from the file f .
  640. (vsid = -1 gets the 1st vDATA). 
  641. RETURNS -1 on error.
  642. RETURNS vdata id (0 or +ve integer) 
  643. */
  644.  
  645. PUBLIC int VSgetid(f,vsid)           /*@-@*/
  646.  
  647. int vsid;
  648. DF  *f;
  649. {
  650.     vsinstance_t * w;
  651.     vfile_t         * vf;
  652.  
  653.     if (vsid < -1) return(FAIL);
  654.  
  655.     if (NULL==(vf = (vfile_t*) Get_vfile(f)))
  656.         RTNEG ("VSgetid: no such file\n");
  657.  
  658.  
  659.     if (vjv) {
  660.         sprintf(sjs,"#VSgetid:vstabn is %d\n",vf->vstabn);
  661.         zj;
  662.     }
  663.  
  664.     if (vsid == -1) {
  665.         if (NULL == vf->vstab.next)
  666.             return (-1);
  667.         else
  668.             return((vf->vstab.next)->ref); /* rets 1st vdata's ref */
  669.     }
  670.  
  671.     /* look in vstab  for vsid */
  672.     w = (vf->vstab).next;
  673.     while(NULL != w) {
  674.         if (w->ref == vsid) break;
  675.         w = w->next;
  676.     }
  677.  
  678.     if (w==NULL)
  679.         return(FAIL);            /* none found */
  680.     else if (w->next == NULL)
  681.         return(FAIL);            /* this is the last vdata, no more after it */
  682.     else
  683.         return( (w->next)->ref);  /* success, return the next vdata's ref */
  684.  
  685. } /* VSgetid */
  686.  
  687. /* ------------------------------------------------------------------ */
  688. /*
  689. zero out n bytes in array x.
  690. */
  691. zerofill(x,n)           /*@@*/
  692. unsigned char* x;
  693. int n;
  694. {
  695.     register int i;
  696.     for(i=0;i<n;i++) *x++ = 0;
  697. } /* zerofill */
  698. /* ------------------------------------------------------------------ */
  699.